package com.api.util;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import net.sf.json.JSON;
import net.sf.json.JSONObject;

public class HttpUtil {
	
	private static String cookieVal = "";

	public static void Get(String url_get, String str_param_url, String charset, String cookie) throws IOException {
		// 拼凑get请求的URL字串，使用URLEncoder.encode对特殊和不可见字符进行编码
		// String getURL = GET_URL + "?username=" + URLEncoder.encode("fat man",
		// "utf-8");
		String getURL = url_get + "?" + str_param_url;
		URL getUrl = new URL(getURL);
		// 根据拼凑的URL，打开连接，URL.openConnection函数会根据URL的类型，
		// 返回不同的URLConnection子类的对象，这里URL是一个http，因此实际返回的是HttpURLConnection
		HttpURLConnection connection = (HttpURLConnection) getUrl.openConnection();

		if (cookie != null) {
			// 发送cookie信息上去，以表明自己的身份，否则会被认为没有权限
			System.out.println("set cookieVal = [" + cookie + "]");
			connection.setRequestProperty("Cookie", cookie);
		}

		// 进行连接，但是实际上get request要在下一句的connection.getInputStream()函数中才会真正发到
		// 服务器
		connection.connect();
		// 取得输入流，并使用Reader读取
		BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), charset));
		System.out.println("Contents of get request:");
		String lines;
		while ((lines = reader.readLine()) != null) {
			System.out.println(lines);
		}
		System.out.println(" ");
		reader.close();
		// 断开连接
		connection.disconnect();
	}

	public static String Post(String url_post, String str_param_body, String charset, boolean b_flag, String cookies)
			throws IOException {
		// Post请求的url，与get不同的是不需要带参数
		URL postUrl = new URL(url_post);
		// 打开连接
		HttpURLConnection connection = (HttpURLConnection) postUrl.openConnection();
		// Output to the connection. Default is
		// false, set to true because post
		// method must write something to the
		// connection
		// 设置是否向connection输出，因为这个是post请求，参数要放在
		// http正文内，因此需要设为true
		if ("" != cookies) {
			connection.setRequestProperty("Cookie", cookies);
		}

		connection.setDoOutput(true);
		// Read from the connection. Default is true.
		connection.setDoInput(true);
		// Set the post method. Default is GET
		connection.setRequestMethod("POST");
		// Post cannot use caches
		// Post 请求不能使用缓存
		connection.setUseCaches(false);
		// This method takes effects to
		// every instances of this class.
		// URLConnection.setFollowRedirects是static函数，作用于所有的URLConnection对象。
		// connection.setFollowRedirects(true);

		// This methods only
		// takes effacts to this
		// instance.
		// URLConnection.setInstanceFollowRedirects是成员函数，仅作用于当前函数
		connection.setInstanceFollowRedirects(b_flag);
		// Set the content type to urlencoded,
		// because we will write
		// some URL-encoded content to the
		// connection. Settings above must be set before connect!
		// 配置本次连接的Content-type，配置为application/x-www-form-urlencoded的
		// 意思是正文是urlencoded编码过的form参数，下面我们可以看到我们对正文内容使用URLEncoder.encode
		// 进行编码Content-Type: application/json
		connection.setRequestProperty("Content-Type", " application/x-www-form-urlencoded; charset=UTF-8");
		connection.setRequestProperty("Connection", "Keep-Alive");// 维持长连接
		connection.setRequestProperty("Referer", "https://api.jinjingzheng.zhongchebaolian.com/enterbj/jsp/enterbj/index.jsp");
		// https://api.jinjingzheng.zhongchebaolian.com/enterbj/jsp/enterbj/index.jsp
		//connection.setRequestProperty("Referer",
		//		"https://api.jinjingzheng.zhongchebaolian.com/enterbj/jsp/enterbj/index.jsp");
		// 连接，从postUrl.openConnection()至此的配置必须要在connect之前完成，
		// 要注意的是connection.getOutputStream会隐含的进行connect。
		connection.connect();
		DataOutputStream out = new DataOutputStream(connection.getOutputStream());
		// The URL-encoded contend
		// 正文，正文内容其实跟get的URL中'?'后的参数字符串一致
		// String content = "userName=" + URLEncoder.encode("console", "utf-8");
		// content = content + "&password=" + URLEncoder.encode("12345678",
		// "utf-8");

		System.out.println("http param body = [" + str_param_body + "]");
		// DataOutputStream.writeBytes将字符串中的16位的unicode字符以8位的字符形式写道流里面
		out.writeBytes(str_param_body);

		out.flush();

		// 取得cookie，相当于记录了身份，供下次访问时使用
		// cookieVal = connection.getHeaderField("Set-Cookie").split(";")[0]
		cookieVal = connection.getHeaderField("Set-Cookie");
		//System.out.println("get cookieVal = [" + cookieVal + "]");

		out.close(); // flush and close
		BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), charset));
		String line;
		StringBuffer sb=new StringBuffer();
		//System.out.println("Contents of post request:");
		while ((line = reader.readLine()) != null) {
			sb.append(line);
		}
		//System.out.println(" ");

		reader.close();
		connection.disconnect();

		return sb.toString();
	}
	
	private static class TrustAnyTrustManager implements X509TrustManager {

		public void checkClientTrusted(X509Certificate[] chain, String authType)
				throws CertificateException {
		}

		public void checkServerTrusted(X509Certificate[] chain, String authType)
				throws CertificateException {
		}

		public X509Certificate[] getAcceptedIssuers() {
			return new X509Certificate[] {};
		}
	}

	private static class TrustAnyHostnameVerifier implements HostnameVerifier {
		public boolean verify(String hostname, SSLSession session) {
			return true;
		}
	}

	/**
	 * post方式请求服务器(https协议)
	 * 
	 * @param url
	 *            请求地址
	 * @param content
	 *            参数
	 * @param charset
	 *            编码
	 * @return
	 * @throws NoSuchAlgorithmException
	 * @throws KeyManagementException
	 * @throws IOException
	 */
	public static byte[] post(String url, String content, String charset)
			throws NoSuchAlgorithmException, KeyManagementException,
			IOException {
		SSLContext sc = SSLContext.getInstance("SSL");
		sc.init(null, new TrustManager[] { new TrustAnyTrustManager() },
				new java.security.SecureRandom());

		URL console = new URL(url);
		HttpsURLConnection conn = (HttpsURLConnection) console.openConnection();
		conn.setSSLSocketFactory(sc.getSocketFactory());
		conn.setHostnameVerifier(new TrustAnyHostnameVerifier());
		conn.setDoOutput(true);
	      // 发送POST请求设置如下两行
        conn.setDoInput(true);
		conn.connect();
		DataOutputStream out = new DataOutputStream(conn.getOutputStream());
		out.write(content.getBytes(charset));
		// 刷新、关闭
		out.flush();
		out.close();
		InputStream is = conn.getInputStream();
		if (is != null) {
			ByteArrayOutputStream outStream = new ByteArrayOutputStream();
			byte[] buffer = new byte[1024];
			int len = 0;
			while ((len = is.read(buffer)) != -1) {
				outStream.write(buffer, 0, len);
			}
			is.close();
			return outStream.toByteArray();
		}
		return null;
	}
	public static JSONObject doPost(String url, String message)
	        {
	    JSONObject jo = null;
	    PrintWriter out = null;
	    InputStream in = null;
	    try {
	        if (url.startsWith("https")){
	        //https方式提交需要
	            SSLContext sc = SSLContext.getInstance("SSL");
	            sc.init(null, new TrustManager[] { new TrustAnyTrustManager() },new java.security.SecureRandom());
	            URL console = new URL(url);
	            HttpsURLConnection conn = (HttpsURLConnection) console.openConnection();
	            conn.setSSLSocketFactory(sc.getSocketFactory());
	            conn.setHostnameVerifier(new TrustAnyHostnameVerifier());
	            conn.connect();
	            in = conn.getInputStream();
	        }else{
	            in = new URL(url).openStream();
	        }
	        // 打开和URL之间的连接
	        URLConnection conn = new URL(url).openConnection();
	        // 设置通用的请求属性
	        conn.setRequestProperty("accept", "*/*");
	        conn.setRequestProperty("connection", "Keep-Alive");
//	        conn.setRequestProperty("user-agent",
//	                "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
	        // 发送POST请求必须设置如下两行
	        conn.setDoOutput(true);
	        conn.setDoInput(true);
	        // 获取URLConnection对象对应的输出流
	        out = new PrintWriter(conn.getOutputStream());
	        // 发送请求参数
	        out.print(message.toString());
	        // flush输出流的缓冲
	        out.flush();
	        // POST请求
	 
	        out.flush();
	        out.close();
	        in = conn.getInputStream();
			if (in != null) {
				ByteArrayOutputStream outStream = new ByteArrayOutputStream();
				byte[] buffer = new byte[1024];
				int len = 0;
				while ((len = in.read(buffer)) != -1) {
					outStream.write(buffer, 0, len);
				}
				in.close();
				
			}
	        System.out.println(in.toString());
	    
	    } catch (IOException e) {
	        e.printStackTrace();
	    } catch (KeyManagementException e) {
	        e.printStackTrace();
	    } catch (NoSuchAlgorithmException e) {
	        e.printStackTrace();
	    } finally {
	        if (out != null) {
	            out.flush();
	            out.close();
	        }
	        if (in != null ){
	            try {
	                in.close();
	            } catch (IOException e) {
	                e.printStackTrace();
	            }
	        }
	    }
	    return jo;
	}
	
    private final static String ENCODE = "UTF-8"; 
    /**
     * URL 解码
     *
     * @return String
     * @author lifq
     * @date 2015-3-17 下午04:09:51
     */
    public static String getURLDecoderString(String str) {
        String result = "";
        if (null == str) {
            return "";
        }
        try {
            result = java.net.URLDecoder.decode(str, ENCODE);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return result;
    }
    /**
     * URL 转码
     *
     * @return String
     * @author lifq
     * @date 2015-3-17 下午04:10:28
     */
    public static String getURLEncoderString(String str) {
        String result = "";
        if (null == str) {
            return "";
        }
        try {
            result = java.net.URLEncoder.encode(str, ENCODE);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return result;
    }
}
